In `@acestep/handler.py`:
- Around line 1608-1617: The VRAM guard in _vram_guard_reduce_batch is checking
self.config_path which initialize_service never sets, so base-model detection
never triggers; update the check to use the existing config object (e.g.,
self.config) instead—inspect self.config.is_turbo or other fields on self.config
to determine base vs turbo and multiply per_sample_gb by 2.0 when appropriate;
ensure this logic is applied where per_sample_gb is computed in
_vram_guard_reduce_batch and remove or stop relying on self.config_path, or set
self.config_path during initialize_service if you prefer that pattern.
- Around line 3709-3718: The VRAM auto-check erroneously runs on non-CUDA
backends (MPS/XPU) because get_effective_free_vram_gb() returns 0 when
torch.cuda.is_available() is false, forcing VAE decode to CPU; change the logic
in the generate_music VAE decision block to only call
get_effective_free_vram_gb() and apply the _effective_free < 0.5 gate when
torch.cuda.is_available() is true (i.e., wrap the effective-free-VRAM check in a
cuda-available conditional), while preserving the ACESTEP_VAE_ON_CPU env
override and the _vae_cpu variable behavior so only CUDA devices can auto-enable
CPU VAE decode.

In `@acestep/third_parts/nano-vllm/nanovllm/engine/model_runner.py`:
- Around line 269-282: The f-string log in model_runner.py uses a Unicode
multiplication sign (×) which triggers RUF001 and can cause copy/paste/terminal
issues; update the print statement that formats KV cache info (the one
referencing config.num_kvcache_blocks, self.block_size, max_tokens_capacity,
kv_cache_size_gb, free, current, target_total_usage, block_bytes, post_kv_free)
to replace the Unicode "×" with a plain ASCII "x" character so the message
becomes e.g. "{config.num_kvcache_blocks} blocks x {self.block_size} tokens =
..." while keeping the rest of the formatting unchanged.

In `@docs/en/ace_step_musicians_guide.md`:
- Around line 157-160: Update the enthusiast tier entry so its batch-size range
follows the tier progression: locate the line containing "16-20 GB (enthusiast)"
and the phrase "1-4 songs at a time" and change it to "2-4 songs at a time"
(keeping the rest of the text, e.g., "Songs up to 10 minutes" and "Larger
Songwriter brain (1.7B)" unchanged) so the lower bound is consistent with the
8-12GB and 12-16GB tiers.

In `@docs/en/BENCHMARK.md`:
- Around line 160-223: The sample output code fence under the "tier-test"
section (the "TIER TEST RESULTS" block) lacks a language tag; update the opening
fence from ``` to ```text to satisfy MD040 and Markdown linting, leaving the
fence contents and closing ``` unchanged so the block is explicitly marked as
plain text.

In `@docs/zh/BENCHMARK.md`:
- Around line 187-199: The fenced code block that begins with "TIER TEST
RESULTS" is missing a language specifier; update the opening fence from ``` to
```text (or another appropriate spec like ```console) so syntax highlighters and
accessibility tools recognize it—modify the code block in the
docs/zh/BENCHMARK.md content around the "TIER TEST RESULTS" section to include
the language tag on the opening backticks.

In `@profile_inference.py`:
- Line 1072: The print call using an unnecessary f-string should be changed to a
regular string: locate the statement print(f"\n  --- Variant: default ---") in
profile_inference.py and remove the leading f so it becomes print("\n  ---
Variant: default ---"); no other behavior changes are needed.
- Around line 1092-1109: Fix the unnecessary f-string prefixes on print
statements that have no interpolations: replace print(f"...") with print("...")
for the messages around the "no-quant" and "no-offload" variants in the block
that calls _run_single_tier_test; specifically update the print calls that
reference the no-quant and no-offload messages which use
gpu_config.quantization_default and gpu_config.offload_to_cpu_default to
determine skips so they are ordinary string literals instead of f-strings.
- Around line 850-853: Remove the now-unnecessary noqa by deleting the "# noqa:
F401" comment on the import flash_attn line in the try block (the import and the
subsequent use of use_flash_attention already satisfy linter rules), i.e.,
update the import flash_attn statement so it no longer includes the noqa
directive.
- Around line 1276-1286: The two print calls that use f-strings without
placeholders should be regular strings: in the block that references
capability_name, failing, and passing (the one that prints the boundary summary
and returns passing[0] if any), replace print(f"    ❌ No tier passed this test.
All tested tiers failed.") and print(f"    ⚠️ No test results available for this
capability.") with print("    ❌ No tier passed this test. All tested tiers
failed.") and print("    ⚠️ No test results available for this capability.")
respectively so the unnecessary f-string prefixes are removed.

In `@scripts/profile_vram.py`:
- Around line 318-321: The code builds encoder_path =
os.path.join(checkpoint_dir, "text_encoder") which doesn't match the runtime
checkpoint name (e.g., "Qwen3-Embedding-0.6B"), so profiling can skip the
encoder; update the logic in scripts/profile_vram.py around encoder_path to try
the runtime checkpoint name as a fallback (check for
os.path.exists(os.path.join(checkpoint_dir, "Qwen3-Embedding-0.6B")) if the
"text_encoder" path is missing) and only return {} after both attempts fail, or
prefer the runtime-named directory when present; ensure references to
encoder_path, checkpoint_dir and the literal names ("text_encoder",
"Qwen3-Embedding-0.6B") are used so the handler and this script align.
- Around line 165-183: The current DiT profiling only allocates and deletes
dummy tensors (noise, text_hidden, text_mask) and never executes the model, so
peak memory misses activation usage; replace the no-op block with a minimal
forward pass by calling the DiT model (e.g., model(noise, text_hidden,
text_mask) or model.forward(...)) inside the torch.inference_mode() context so
activations are allocated and measured, and when has_cfg is true duplicate the
inputs (noise_cfg, text_hidden_cfg, text_mask_cfg) and pass the doubled batch to
the model to simulate classifier-free guidance; alternatively, if you
intentionally only want to measure input allocation, rename peak_inference_gb to
peak_input_allocation_gb to reflect the narrower measurement.

In `@docs/en/GPU_COMPATIBILITY.md`:
- Around line 141-149: The fenced code block showing the "BOUNDARY ANALYSIS"
table lacks a language specifier; update the opening fence that precedes the
BOUNDARY ANALYSIS block from ``` to ```text so the block is explicitly marked as
plain text (look for the lines containing the literal "BOUNDARY ANALYSIS" and
the surrounding triple-backtick fence and change the opening fence accordingly).
- Around line 79-83: Update the tier labels for the GPU simulation examples:
change the comment "Simulate an 8GB GPU (Tier 4)" to "Simulate an 8GB GPU (Tier
3)" and change "Simulate a 12GB GPU (Tier 5)" to "Simulate a 12GB GPU (Tier 4)"
for the lines with MAX_CUDA_VRAM=8 uv run acestep and MAX_CUDA_VRAM=12 uv run
acestep so the examples match the mapping (≤8GB → tier3, ≤12GB → tier4).

In `@docs/ja/GPU_COMPATIBILITY.md`:
- Around line 79-83: Update the comment labels for the GPU simulation examples:
change the "8GB GPU (Tier 4) をシミュレート" comment to "8GB GPU (Tier 3) をシミュレート" and
change the "12GB GPU (Tier 5) をシミュレート" comment to "12GB GPU (Tier 4) をシミュレート" so
the comments match the tier mapping for the MAX_CUDA_VRAM examples (the lines
using MAX_CUDA_VRAM=8 and MAX_CUDA_VRAM=12 before running "uv run acestep").

In `@docs/ko/GPU_COMPATIBILITY.md`:
- Around line 79-83: The tier labels are incorrect for the 8GB/12GB examples;
update the headings for the examples shown (the commented lines above the
commands using MAX_CUDA_VRAM and uv run acestep) so the 8GB example reads "8GB
GPU 시뮬레이션 (티어 3)" and the 12GB example reads "12GB GPU 시뮬레이션 (티어 4)" to match
the mapping ≤8GB → tier3 and ≤12GB → tier4.

In `@docs/zh/BENCHMARK.md`:
- Around line 165-166: Update the "测试所有等级" section so the listed tiers match the
actual default tiers used by profile_inference.py; replace the current list
(which shows 20GB and omits 48GB) with the real defaults (include 48GB and
remove 20GB), or add a short note stating that 20GB is not a default and must be
provided via the --tiers flag; refer to the "python profile_inference.py --mode
tier-test" invocation and the default tier list in the script when making the
change.

In `@docs/zh/GPU_COMPATIBILITY.md`:
- Around line 141-149: The fenced code block that starts with the "BOUNDARY
ANALYSIS" header should include a language specifier to ensure proper rendering;
update the opening triple-backtick for the block containing "BOUNDARY ANALYSIS"
and the table (the block that currently begins with ``` and the header line
"BOUNDARY ANALYSIS") to use a language tag (e.g., change ``` to ```text) so the
table renders as plain text in documentation.
- Around line 79-83: Update the tier labels in the examples: change the heading
"模拟 8GB GPU (Tier 4)" to "模拟 8GB GPU (Tier 3)" and change "模拟 12GB GPU (Tier 5)"
to "模拟 12GB GPU (Tier 4)"; keep the example commands (MAX_CUDA_VRAM=8 uv run
acestep and MAX_CUDA_VRAM=12 uv run acestep) unchanged and ensure the
documentation reflects the mapping ≤8GB → tier3 and ≤12GB → tier4.

In `@profile_inference.py`:
- Around line 789-798: The code may pick a disk-only LM that is too large for
the current tier because disk_lm_models are not filtered by tier size; before
calling find_best_lm_model_on_disk, filter disk_lm_models to only include models
whose size is compatible with the current tier (use the tier variable and
gpu_config-recommended sizing rules) and then pass that filtered list to
find_best_lm_model_on_disk (keep references to lm_model, use_lm,
find_best_lm_model_on_disk, disk_lm_models, gpu_config.recommended_lm_model and
tier so the change is easy to locate).
- Around line 815-823: The current CUDA memory-fraction logic only sets a
reduced fraction when sim_gb < physical VRAM, but doesn't reset the per-process
cap when sim_gb >= physical VRAM, leaving a prior smaller cap in place; update
the block in profile_inference.py that checks torch.cuda.is_available() (the
code using torch.cuda.get_device_properties, total_gb, sim_gb and
torch.cuda.set_per_process_memory_fraction) so that when sim_gb >= total_gb you
explicitly call torch.cuda.set_per_process_memory_fraction(1.0) to clear any
previous cap; retain the existing reduced-fraction calculation path for sim_gb <
total_gb.

In `@acestep/handler.py`:
- Around line 1605-1607: The device check currently compares the device variable
to strings and can miss non-CUDA devices (e.g., torch.device objects like
"xpu"), causing CUDA-only VRAM logic to run incorrectly; update the check in the
handler where device is read (the block using device = self.device and the
similar block at the later occurrence) to reliably detect CUDA by converting to
string or using device.type (e.g., if str(device) in ("cpu","mps") or if
getattr(device,"type",str(device)) in ("cpu","mps")), and keep the subsequent
call to get_effective_free_vram_gb() only for CUDA devices so batch_size isn't
forced to 1 on non-CUDA devices.